
// Generated from Jass.g4 by ANTLR 4.13.2

#pragma once


#include "antlr4-runtime.h"


namespace antlrcppjassparser {


class  JassParser : public antlr4::Parser {
public:
  enum {
    T__0 = 1, T__1 = 2, T__2 = 3, T__3 = 4, T__4 = 5, T__5 = 6, T__6 = 7, 
    T__7 = 8, T__8 = 9, T__9 = 10, T__10 = 11, T__11 = 12, T__12 = 13, T__13 = 14, 
    T__14 = 15, EQUALS = 16, GLOBALS = 17, ENDGLOBALS = 18, NATIVE = 19, 
    FUNCTION = 20, TAKES = 21, RETURNS = 22, ENDFUNCTION = 23, NOTHING = 24, 
    CALL = 25, SET = 26, RETURN = 27, ARRAY = 28, TYPE = 29, EXTENDS = 30, 
    IF = 31, THEN = 32, ELSE = 33, ENDIF = 34, ELSEIF = 35, CONSTANT = 36, 
    LOCAL = 37, LOOP = 38, ENDLOOP = 39, EXITWHEN = 40, DEBUG = 41, STRING_LITERAL = 42, 
    INTEGER = 43, HEX_CONSTANT = 44, DOLLAR_HEX_CONSTANT = 45, RAWCODE = 46, 
    REAL = 47, NULL_ = 48, TRUE = 49, FALSE = 50, NOT = 51, OR = 52, AND = 53, 
    ID = 54, WS = 55, NEWLINE = 56
  };

  enum {
    RuleProgram = 0, RuleTypeDeclaration = 1, RuleType = 2, RuleGlobal = 3, 
    RuleLocal = 4, RuleAssignTail = 5, RuleMultDivExpression = 6, RuleSimpleArithmeticExpression = 7, 
    RuleBoolComparisonExpression = 8, RuleBoolEqualityExpression = 9, RuleBoolAndsExpression = 10, 
    RuleBoolExpression = 11, RuleBaseExpression = 12, RuleExpression = 13, 
    RuleFunctionExpression = 14, RuleArgsList = 15, RuleStatement = 16, 
    RuleIfStatementPartial = 17, RuleParam = 18, RuleParamList = 19, RuleGlobalsBlock = 20, 
    RuleTypeDeclarationBlock = 21, RuleNativeBlock = 22, RuleBlock = 23, 
    RuleFunctionBlock = 24, RuleStatements = 25, RuleNewlines = 26, RuleNewlines_opt = 27, 
    RulePnewlines = 28
  };

  explicit JassParser(antlr4::TokenStream *input);

  JassParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);

  ~JassParser() override;

  std::string getGrammarFileName() const override;

  const antlr4::atn::ATN& getATN() const override;

  const std::vector<std::string>& getRuleNames() const override;

  const antlr4::dfa::Vocabulary& getVocabulary() const override;

  antlr4::atn::SerializedATNView getSerializedATN() const override;


  class ProgramContext;
  class TypeDeclarationContext;
  class TypeContext;
  class GlobalContext;
  class LocalContext;
  class AssignTailContext;
  class MultDivExpressionContext;
  class SimpleArithmeticExpressionContext;
  class BoolComparisonExpressionContext;
  class BoolEqualityExpressionContext;
  class BoolAndsExpressionContext;
  class BoolExpressionContext;
  class BaseExpressionContext;
  class ExpressionContext;
  class FunctionExpressionContext;
  class ArgsListContext;
  class StatementContext;
  class IfStatementPartialContext;
  class ParamContext;
  class ParamListContext;
  class GlobalsBlockContext;
  class TypeDeclarationBlockContext;
  class NativeBlockContext;
  class BlockContext;
  class FunctionBlockContext;
  class StatementsContext;
  class NewlinesContext;
  class Newlines_optContext;
  class PnewlinesContext; 

  class  ProgramContext : public antlr4::ParserRuleContext {
  public:
    ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    NewlinesContext *newlines();
    Newlines_optContext *newlines_opt();
    TypeDeclarationBlockContext *typeDeclarationBlock();
    std::vector<BlockContext *> block();
    BlockContext* block(size_t i);
    std::vector<FunctionBlockContext *> functionBlock();
    FunctionBlockContext* functionBlock(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  ProgramContext* program();

  class  TypeDeclarationContext : public antlr4::ParserRuleContext {
  public:
    TypeDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *TYPE();
    std::vector<antlr4::tree::TerminalNode *> ID();
    antlr4::tree::TerminalNode* ID(size_t i);
    antlr4::tree::TerminalNode *EXTENDS();
    NewlinesContext *newlines();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  TypeDeclarationContext* typeDeclaration();

  class  TypeContext : public antlr4::ParserRuleContext {
  public:
    TypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    TypeContext() = default;
    void copyFrom(TypeContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  ArrayTypeContext : public TypeContext {
  public:
    ArrayTypeContext(TypeContext *ctx);

    antlr4::tree::TerminalNode *ID();
    antlr4::tree::TerminalNode *ARRAY();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BasicTypeContext : public TypeContext {
  public:
    BasicTypeContext(TypeContext *ctx);

    antlr4::tree::TerminalNode *ID();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  NothingTypeContext : public TypeContext {
  public:
    NothingTypeContext(TypeContext *ctx);

    antlr4::tree::TerminalNode *NOTHING();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  TypeContext* type();

  class  GlobalContext : public antlr4::ParserRuleContext {
  public:
    GlobalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    GlobalContext() = default;
    void copyFrom(GlobalContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  DefinitionGlobalContext : public GlobalContext {
  public:
    DefinitionGlobalContext(GlobalContext *ctx);

    TypeContext *type();
    antlr4::tree::TerminalNode *ID();
    AssignTailContext *assignTail();
    NewlinesContext *newlines();
    antlr4::tree::TerminalNode *CONSTANT();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BasicGlobalContext : public GlobalContext {
  public:
    BasicGlobalContext(GlobalContext *ctx);

    TypeContext *type();
    antlr4::tree::TerminalNode *ID();
    NewlinesContext *newlines();
    antlr4::tree::TerminalNode *CONSTANT();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  GlobalContext* global();

  class  LocalContext : public antlr4::ParserRuleContext {
  public:
    LocalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    LocalContext() = default;
    void copyFrom(LocalContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  BasicLocalContext : public LocalContext {
  public:
    BasicLocalContext(LocalContext *ctx);

    antlr4::tree::TerminalNode *LOCAL();
    TypeContext *type();
    antlr4::tree::TerminalNode *ID();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  DefinitionLocalContext : public LocalContext {
  public:
    DefinitionLocalContext(LocalContext *ctx);

    antlr4::tree::TerminalNode *LOCAL();
    TypeContext *type();
    antlr4::tree::TerminalNode *ID();
    AssignTailContext *assignTail();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  LocalContext* local();

  class  AssignTailContext : public antlr4::ParserRuleContext {
  public:
    AssignTailContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *EQUALS();
    ExpressionContext *expression();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  AssignTailContext* assignTail();

  class  MultDivExpressionContext : public antlr4::ParserRuleContext {
  public:
    MultDivExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    MultDivExpressionContext() = default;
    void copyFrom(MultDivExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  BaseMultiplicationExpressionContext : public MultDivExpressionContext {
  public:
    BaseMultiplicationExpressionContext(MultDivExpressionContext *ctx);

    BaseExpressionContext *baseExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  DivisionExpressionContext : public MultDivExpressionContext {
  public:
    DivisionExpressionContext(MultDivExpressionContext *ctx);

    MultDivExpressionContext *multDivExpression();
    BaseExpressionContext *baseExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  MultiplicationExpressionContext : public MultDivExpressionContext {
  public:
    MultiplicationExpressionContext(MultDivExpressionContext *ctx);

    MultDivExpressionContext *multDivExpression();
    BaseExpressionContext *baseExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  MultDivExpressionContext* multDivExpression();
  MultDivExpressionContext* multDivExpression(int precedence);
  class  SimpleArithmeticExpressionContext : public antlr4::ParserRuleContext {
  public:
    SimpleArithmeticExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    SimpleArithmeticExpressionContext() = default;
    void copyFrom(SimpleArithmeticExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  AdditionExpressionContext : public SimpleArithmeticExpressionContext {
  public:
    AdditionExpressionContext(SimpleArithmeticExpressionContext *ctx);

    SimpleArithmeticExpressionContext *simpleArithmeticExpression();
    MultDivExpressionContext *multDivExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  SubtrationExpressionContext : public SimpleArithmeticExpressionContext {
  public:
    SubtrationExpressionContext(SimpleArithmeticExpressionContext *ctx);

    SimpleArithmeticExpressionContext *simpleArithmeticExpression();
    MultDivExpressionContext *multDivExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BaseAdditionExpressionContext : public SimpleArithmeticExpressionContext {
  public:
    BaseAdditionExpressionContext(SimpleArithmeticExpressionContext *ctx);

    MultDivExpressionContext *multDivExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  SimpleArithmeticExpressionContext* simpleArithmeticExpression();
  SimpleArithmeticExpressionContext* simpleArithmeticExpression(int precedence);
  class  BoolComparisonExpressionContext : public antlr4::ParserRuleContext {
  public:
    BoolComparisonExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    BoolComparisonExpressionContext() = default;
    void copyFrom(BoolComparisonExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  BooleanLessExpressionContext : public BoolComparisonExpressionContext {
  public:
    BooleanLessExpressionContext(BoolComparisonExpressionContext *ctx);

    BoolComparisonExpressionContext *boolComparisonExpression();
    SimpleArithmeticExpressionContext *simpleArithmeticExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BooleanGreaterExpressionContext : public BoolComparisonExpressionContext {
  public:
    BooleanGreaterExpressionContext(BoolComparisonExpressionContext *ctx);

    BoolComparisonExpressionContext *boolComparisonExpression();
    SimpleArithmeticExpressionContext *simpleArithmeticExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BaseBoolComparisonExpressionContext : public BoolComparisonExpressionContext {
  public:
    BaseBoolComparisonExpressionContext(BoolComparisonExpressionContext *ctx);

    SimpleArithmeticExpressionContext *simpleArithmeticExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BooleanLessOrEqualsExpressionContext : public BoolComparisonExpressionContext {
  public:
    BooleanLessOrEqualsExpressionContext(BoolComparisonExpressionContext *ctx);

    BoolComparisonExpressionContext *boolComparisonExpression();
    SimpleArithmeticExpressionContext *simpleArithmeticExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BooleanGreaterOrEqualsExpressionContext : public BoolComparisonExpressionContext {
  public:
    BooleanGreaterOrEqualsExpressionContext(BoolComparisonExpressionContext *ctx);

    BoolComparisonExpressionContext *boolComparisonExpression();
    SimpleArithmeticExpressionContext *simpleArithmeticExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  BoolComparisonExpressionContext* boolComparisonExpression();
  BoolComparisonExpressionContext* boolComparisonExpression(int precedence);
  class  BoolEqualityExpressionContext : public antlr4::ParserRuleContext {
  public:
    BoolEqualityExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    BoolEqualityExpressionContext() = default;
    void copyFrom(BoolEqualityExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  NotEqualsExpressionContext : public BoolEqualityExpressionContext {
  public:
    NotEqualsExpressionContext(BoolEqualityExpressionContext *ctx);

    BoolEqualityExpressionContext *boolEqualityExpression();
    BoolComparisonExpressionContext *boolComparisonExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BaseBoolExpressionContext : public BoolEqualityExpressionContext {
  public:
    BaseBoolExpressionContext(BoolEqualityExpressionContext *ctx);

    BoolComparisonExpressionContext *boolComparisonExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  EqualsExpressionContext : public BoolEqualityExpressionContext {
  public:
    EqualsExpressionContext(BoolEqualityExpressionContext *ctx);

    BoolEqualityExpressionContext *boolEqualityExpression();
    BoolComparisonExpressionContext *boolComparisonExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  BoolEqualityExpressionContext* boolEqualityExpression();
  BoolEqualityExpressionContext* boolEqualityExpression(int precedence);
  class  BoolAndsExpressionContext : public antlr4::ParserRuleContext {
  public:
    BoolAndsExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    BoolAndsExpressionContext() = default;
    void copyFrom(BoolAndsExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  BaseBoolAndsExpressionContext : public BoolAndsExpressionContext {
  public:
    BaseBoolAndsExpressionContext(BoolAndsExpressionContext *ctx);

    BoolEqualityExpressionContext *boolEqualityExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BooleanAndExpressionContext : public BoolAndsExpressionContext {
  public:
    BooleanAndExpressionContext(BoolAndsExpressionContext *ctx);

    BoolAndsExpressionContext *boolAndsExpression();
    antlr4::tree::TerminalNode *AND();
    BoolEqualityExpressionContext *boolEqualityExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  BoolAndsExpressionContext* boolAndsExpression();
  BoolAndsExpressionContext* boolAndsExpression(int precedence);
  class  BoolExpressionContext : public antlr4::ParserRuleContext {
  public:
    BoolExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    BoolExpressionContext() = default;
    void copyFrom(BoolExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  BaseBoolOrsExpressionContext : public BoolExpressionContext {
  public:
    BaseBoolOrsExpressionContext(BoolExpressionContext *ctx);

    BoolAndsExpressionContext *boolAndsExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  BooleanOrExpressionContext : public BoolExpressionContext {
  public:
    BooleanOrExpressionContext(BoolExpressionContext *ctx);

    BoolExpressionContext *boolExpression();
    antlr4::tree::TerminalNode *OR();
    BoolAndsExpressionContext *boolAndsExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  BoolExpressionContext* boolExpression();
  BoolExpressionContext* boolExpression(int precedence);
  class  BaseExpressionContext : public antlr4::ParserRuleContext {
  public:
    BaseExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    BaseExpressionContext() = default;
    void copyFrom(BaseExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  ParentheticalExpressionContext : public BaseExpressionContext {
  public:
    ParentheticalExpressionContext(BaseExpressionContext *ctx);

    ExpressionContext *expression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  StringLiteralExpressionContext : public BaseExpressionContext {
  public:
    StringLiteralExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *STRING_LITERAL();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  DollarHexIntegerLiteralExpressionContext : public BaseExpressionContext {
  public:
    DollarHexIntegerLiteralExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *DOLLAR_HEX_CONSTANT();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  FunctionReferenceExpressionContext : public BaseExpressionContext {
  public:
    FunctionReferenceExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *FUNCTION();
    antlr4::tree::TerminalNode *ID();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  HexIntegerLiteralExpressionContext : public BaseExpressionContext {
  public:
    HexIntegerLiteralExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *HEX_CONSTANT();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  NotExpressionContext : public BaseExpressionContext {
  public:
    NotExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *NOT();
    BaseExpressionContext *baseExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  FunctionCallExpressionContext : public BaseExpressionContext {
  public:
    FunctionCallExpressionContext(BaseExpressionContext *ctx);

    FunctionExpressionContext *functionExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  NullExpressionContext : public BaseExpressionContext {
  public:
    NullExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *NULL_();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  NegateExpressionContext : public BaseExpressionContext {
  public:
    NegateExpressionContext(BaseExpressionContext *ctx);

    BaseExpressionContext *baseExpression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  RawcodeLiteralExpressionContext : public BaseExpressionContext {
  public:
    RawcodeLiteralExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *RAWCODE();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  TrueExpressionContext : public BaseExpressionContext {
  public:
    TrueExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *TRUE();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  IntegerLiteralExpressionContext : public BaseExpressionContext {
  public:
    IntegerLiteralExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *INTEGER();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  ReferenceExpressionContext : public BaseExpressionContext {
  public:
    ReferenceExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *ID();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  RealLiteralExpressionContext : public BaseExpressionContext {
  public:
    RealLiteralExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *REAL();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  ArrayReferenceExpressionContext : public BaseExpressionContext {
  public:
    ArrayReferenceExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *ID();
    ExpressionContext *expression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  FalseExpressionContext : public BaseExpressionContext {
  public:
    FalseExpressionContext(BaseExpressionContext *ctx);

    antlr4::tree::TerminalNode *FALSE();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  BaseExpressionContext* baseExpression();

  class  ExpressionContext : public antlr4::ParserRuleContext {
  public:
    ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    BoolExpressionContext *boolExpression();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  ExpressionContext* expression();

  class  FunctionExpressionContext : public antlr4::ParserRuleContext {
  public:
    FunctionExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *ID();
    ArgsListContext *argsList();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FunctionExpressionContext* functionExpression();

  class  ArgsListContext : public antlr4::ParserRuleContext {
  public:
    ArgsListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    ArgsListContext() = default;
    void copyFrom(ArgsListContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  SingleArgumentContext : public ArgsListContext {
  public:
    SingleArgumentContext(ArgsListContext *ctx);

    ExpressionContext *expression();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  EmptyArgumentContext : public ArgsListContext {
  public:
    EmptyArgumentContext(ArgsListContext *ctx);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  ListArgumentContext : public ArgsListContext {
  public:
    ListArgumentContext(ArgsListContext *ctx);

    ExpressionContext *expression();
    ArgsListContext *argsList();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  ArgsListContext* argsList();

  class  StatementContext : public antlr4::ParserRuleContext {
  public:
    StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    StatementContext() = default;
    void copyFrom(StatementContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  ArrayedAssignmentStatementContext : public StatementContext {
  public:
    ArrayedAssignmentStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *SET();
    antlr4::tree::TerminalNode *ID();
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode *EQUALS();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  IfStatementContext : public StatementContext {
  public:
    IfStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *IF();
    IfStatementPartialContext *ifStatementPartial();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  LocalStatementContext : public StatementContext {
  public:
    LocalStatementContext(StatementContext *ctx);

    LocalContext *local();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  ReturnStatementContext : public StatementContext {
  public:
    ReturnStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *RETURN();
    ExpressionContext *expression();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  CallStatementContext : public StatementContext {
  public:
    CallStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *CALL();
    FunctionExpressionContext *functionExpression();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  LoopStatementContext : public StatementContext {
  public:
    LoopStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *LOOP();
    std::vector<NewlinesContext *> newlines();
    NewlinesContext* newlines(size_t i);
    StatementsContext *statements();
    antlr4::tree::TerminalNode *ENDLOOP();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  DebugStatementContext : public StatementContext {
  public:
    DebugStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *DEBUG();
    StatementContext *statement();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  ExitWhenStatementContext : public StatementContext {
  public:
    ExitWhenStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *EXITWHEN();
    ExpressionContext *expression();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  SetStatementContext : public StatementContext {
  public:
    SetStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *SET();
    antlr4::tree::TerminalNode *ID();
    antlr4::tree::TerminalNode *EQUALS();
    ExpressionContext *expression();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  ReturnNothingStatementContext : public StatementContext {
  public:
    ReturnNothingStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *RETURN();
    NewlinesContext *newlines();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  StatementContext* statement();

  class  IfStatementPartialContext : public antlr4::ParserRuleContext {
  public:
    IfStatementPartialContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    IfStatementPartialContext() = default;
    void copyFrom(IfStatementPartialContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  IfElseIfStatementContext : public IfStatementPartialContext {
  public:
    IfElseIfStatementContext(IfStatementPartialContext *ctx);

    ExpressionContext *expression();
    antlr4::tree::TerminalNode *THEN();
    NewlinesContext *newlines();
    StatementsContext *statements();
    antlr4::tree::TerminalNode *ELSEIF();
    IfStatementPartialContext *ifStatementPartial();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  IfElseStatementContext : public IfStatementPartialContext {
  public:
    IfElseStatementContext(IfStatementPartialContext *ctx);

    ExpressionContext *expression();
    antlr4::tree::TerminalNode *THEN();
    std::vector<NewlinesContext *> newlines();
    NewlinesContext* newlines(size_t i);
    std::vector<StatementsContext *> statements();
    StatementsContext* statements(size_t i);
    antlr4::tree::TerminalNode *ELSE();
    antlr4::tree::TerminalNode *ENDIF();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  SimpleIfStatementContext : public IfStatementPartialContext {
  public:
    SimpleIfStatementContext(IfStatementPartialContext *ctx);

    ExpressionContext *expression();
    antlr4::tree::TerminalNode *THEN();
    std::vector<NewlinesContext *> newlines();
    NewlinesContext* newlines(size_t i);
    StatementsContext *statements();
    antlr4::tree::TerminalNode *ENDIF();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  IfStatementPartialContext* ifStatementPartial();

  class  ParamContext : public antlr4::ParserRuleContext {
  public:
    ParamContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    TypeContext *type();
    antlr4::tree::TerminalNode *ID();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  ParamContext* param();

  class  ParamListContext : public antlr4::ParserRuleContext {
  public:
    ParamListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    ParamListContext() = default;
    void copyFrom(ParamListContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;

   
  };

  class  NothingParameterContext : public ParamListContext {
  public:
    NothingParameterContext(ParamListContext *ctx);

    antlr4::tree::TerminalNode *NOTHING();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  SingleParameterContext : public ParamListContext {
  public:
    SingleParameterContext(ParamListContext *ctx);

    ParamContext *param();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  class  ListParameterContext : public ParamListContext {
  public:
    ListParameterContext(ParamListContext *ctx);

    ParamContext *param();
    ParamListContext *paramList();
    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
  };

  ParamListContext* paramList();

  class  GlobalsBlockContext : public antlr4::ParserRuleContext {
  public:
    GlobalsBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *GLOBALS();
    std::vector<NewlinesContext *> newlines();
    NewlinesContext* newlines(size_t i);
    antlr4::tree::TerminalNode *ENDGLOBALS();
    std::vector<GlobalContext *> global();
    GlobalContext* global(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  GlobalsBlockContext* globalsBlock();

  class  TypeDeclarationBlockContext : public antlr4::ParserRuleContext {
  public:
    TypeDeclarationBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<TypeDeclarationContext *> typeDeclaration();
    TypeDeclarationContext* typeDeclaration(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  TypeDeclarationBlockContext* typeDeclarationBlock();

  class  NativeBlockContext : public antlr4::ParserRuleContext {
  public:
    NativeBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *NATIVE();
    antlr4::tree::TerminalNode *ID();
    antlr4::tree::TerminalNode *TAKES();
    ParamListContext *paramList();
    antlr4::tree::TerminalNode *RETURNS();
    TypeContext *type();
    NewlinesContext *newlines();
    antlr4::tree::TerminalNode *CONSTANT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  NativeBlockContext* nativeBlock();

  class  BlockContext : public antlr4::ParserRuleContext {
  public:
    BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    GlobalsBlockContext *globalsBlock();
    NativeBlockContext *nativeBlock();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  BlockContext* block();

  class  FunctionBlockContext : public antlr4::ParserRuleContext {
  public:
    FunctionBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *FUNCTION();
    antlr4::tree::TerminalNode *ID();
    antlr4::tree::TerminalNode *TAKES();
    ParamListContext *paramList();
    antlr4::tree::TerminalNode *RETURNS();
    TypeContext *type();
    std::vector<NewlinesContext *> newlines();
    NewlinesContext* newlines(size_t i);
    StatementsContext *statements();
    antlr4::tree::TerminalNode *ENDFUNCTION();
    antlr4::tree::TerminalNode *CONSTANT();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  FunctionBlockContext* functionBlock();

  class  StatementsContext : public antlr4::ParserRuleContext {
  public:
    StatementsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    std::vector<StatementContext *> statement();
    StatementContext* statement(size_t i);

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  StatementsContext* statements();

  class  NewlinesContext : public antlr4::ParserRuleContext {
  public:
    NewlinesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    PnewlinesContext *pnewlines();
    antlr4::tree::TerminalNode *EOF();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  NewlinesContext* newlines();

  class  Newlines_optContext : public antlr4::ParserRuleContext {
  public:
    Newlines_optContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    PnewlinesContext *pnewlines();
    antlr4::tree::TerminalNode *EOF();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  Newlines_optContext* newlines_opt();

  class  PnewlinesContext : public antlr4::ParserRuleContext {
  public:
    PnewlinesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    antlr4::tree::TerminalNode *NEWLINE();
    NewlinesContext *newlines();

    virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
    virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;

    virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
   
  };

  PnewlinesContext* pnewlines();


  bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;

  bool multDivExpressionSempred(MultDivExpressionContext *_localctx, size_t predicateIndex);
  bool simpleArithmeticExpressionSempred(SimpleArithmeticExpressionContext *_localctx, size_t predicateIndex);
  bool boolComparisonExpressionSempred(BoolComparisonExpressionContext *_localctx, size_t predicateIndex);
  bool boolEqualityExpressionSempred(BoolEqualityExpressionContext *_localctx, size_t predicateIndex);
  bool boolAndsExpressionSempred(BoolAndsExpressionContext *_localctx, size_t predicateIndex);
  bool boolExpressionSempred(BoolExpressionContext *_localctx, size_t predicateIndex);

  // By default the static state used to implement the parser is lazily initialized during the first
  // call to the constructor. You can call this function if you wish to initialize the static state
  // ahead of time.
  static void initialize();

private:
};

}  // namespace antlrcppjassparser
